import serial

#OJO, el wav tiene que tener 1 canal y tener 8 bits de bit-depth
#path="/home/kmels/code/uvg/ed2010-music-player/sound-tests/baja-calidad/smb_stage_clear.wav"
path = ""
baudrate = 0
puerto = ""
conexion = serial.Serial(0)

def cambiar_frecuencia(value):
    global baudrate
    baudrate = value

def cambiar_puerto(value):
    global puerto
    puerto = value

#manda los comandos para inicializar la SD, modo SPI

#####################################################
### write(hex)                                    ###
### recibe un hexadecimal y escribe en el puerto  ###
### un char con el binario invertido              ###
#####################################################
def write_hex(to_write_hex):
    binario = bin(to_write_hex)[2:]
    binario = binario[::-1]
    while(len(binario)!=8):
        binario+='0'
    binario = '0b'+binario
    temp = chr(int(binario,2))#binario, en base dos
    write(temp)

#####################################################
### write(char)                                   ###
### recibe un char y lo escribe directo en el     ###
### puerto                                        ###
#####################################################
def write(temp):
    global conexion
    conexion.write(temp)
   

def inicializar_memoria():
    global conexion, puerto, baudrate
    
    conexion.port = puerto
    conexion.baudrate = baudrate
    
    conexion.open()
    
    #Resetear (8)
    i=0
    while(i<1):
        write_hex(0xFF)
        write_hex(0xFF)
        write_hex(0x40)
        write_hex(0x00)
        write_hex(0x00)
        write_hex(0x00)
        write_hex(0x00)
        write_hex(0x95)
        
        j = 0
        while(j<0):
            write_hex(0xFF)
            j+=1
        
        i+=1
    i=0
    '''
    #SPI to CMD1 (8, van 16)
    while(i<1):
        write_hex(0xFF)
        write_hex(0xFF)
        write_hex(0x41)
        write_hex(0x00)
        write_hex(0x00)
        write_hex(0x00)
        write_hex(0x00)
        write_hex(0xFF)
        i+=1
    i=0
    while(i<1):
    #Configurar palabra a 512 bytes (8, van 24)
        write_hex(0xFF)
        write_hex(0xFF)
        write_hex(0x50)
        write_hex(0x00)
        write_hex(0x00)
        write_hex(0x02)
        write_hex(0x00)
        write_hex(0x00)
        i+=1
    '''
    conexion.close()
    
#convierte un archivo wav a un archivo con formato .raw 
def convertir_a_headerless_y_transmitir(path_al_archivo_wav):
    archivo = open(path_al_archivo_wav,"r") 
    bytes_del_header = archivo.read(44) #leer 44 bytes de header
    bytes_de_sonido = archivo.read(-1) #leer el resto
    transmitir_cancion(bytes_de_sonido)

#Escribe un segmento en la direccion que dice el parametro direccion_segmento (de tipo byte, e.g. 0x04), mandando los comandos a la SD, el parametro data tiene que ser un arreglo de bytes de  tamano 512
def escribir_segmento(data,segmento):
    if len(data) != 512: #verificar que va a escribir 512
        print "La data no son 512 bytes, es ",len(data)
        return

    #comando para escribir
    write_hex(0xFF)
    write_hex(0xFF)
    write_hex(0x58)
    write_hex(0x00)

    #especificar direccion
    write_hex(0x00)
    write_hex(direccion_segmento)         
    write_hex(0x00)
    write_hex(0x00)

    #Comando para escribir
    write_hex(0xFF)
    write_hex(0xFF)
    write_hex(0xFE)

    #escribir data
    for byte in data:
        write_hex(byte)
        
    #comando de final de data
    write_hex(0xFF)
    write_hex(0xFF)


def transmitir_cancion(bytes_de_sonido):
    global puerto, baudrate, conexion
    
    #abrir conexion
    
    conexion.port = puerto
    conexion.baudrate = baudrate
    
    print(conexion)
    
    conexion.open()
    
    tamano_segmento = 512
    #dividir bytes de sonido en segmentos de 512 bytes cada uno
    data_segmentos = [bytes_de_sonido[seg_i:seg_i+tamano_segmento] for seg_i in range(0,len(bytes_de_sonido),tamano_segmento)]
    
    if len(bytes_de_sonido) % tamano_segmento == 0:
        #estan cabales?
        cantidad_segmentos = len(bytes_de_sonido)/tamano_segmento
    else:
        #falta
        cantidad_segmentos = len(bytes_de_sonido)/tamano_segmento + 1
        por_completar = tamano_segmento - len(bytes_de_sonido)%tamano_segmento
        for i in range(0,por_completar):
            data_segmentos[cantidad_segmentos-1]

    #completar el ultimo para que tenga 512
    
    
    #inicializar memoria
    inicializar_memoria()
    
    #escribir segmentos
    #segmento_i = 0
    #for data_segmento in data_segmentos:
    #    escribir_segmento(data_segmento,0x04+segmento_i)
    #    segmento_i += 1
    
    conexion.close()

